home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / pickle.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  38KB  |  1,398 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''Create portable serialized representations of Python objects.
  5.  
  6. See module cPickle for a (much) faster implementation.
  7. See module copy_reg for a mechanism for registering custom picklers.
  8. See module pickletools source for extensive comments.
  9.  
  10. Classes:
  11.  
  12.     Pickler
  13.     Unpickler
  14.  
  15. Functions:
  16.  
  17.     dump(object, file)
  18.     dumps(object) -> string
  19.     load(file) -> object
  20.     loads(string) -> object
  21.  
  22. Misc variables:
  23.  
  24.     __version__
  25.     format_version
  26.     compatible_formats
  27.  
  28. '''
  29. __version__ = '$Revision: 1.158 $'
  30. from types import *
  31. from copy_reg import dispatch_table
  32. from copy_reg import _extension_registry, _inverted_registry, _extension_cache
  33. import marshal
  34. import sys
  35. import struct
  36. import re
  37. import warnings
  38. __all__ = [
  39.     'PickleError',
  40.     'PicklingError',
  41.     'UnpicklingError',
  42.     'Pickler',
  43.     'Unpickler',
  44.     'dump',
  45.     'dumps',
  46.     'load',
  47.     'loads']
  48. format_version = '2.0'
  49. compatible_formats = [
  50.     '1.0',
  51.     '1.1',
  52.     '1.2',
  53.     '1.3',
  54.     '2.0']
  55. HIGHEST_PROTOCOL = 2
  56. mloads = marshal.loads
  57.  
  58. class PickleError(Exception):
  59.     '''A common base class for the other pickling exceptions.'''
  60.     pass
  61.  
  62.  
  63. class PicklingError(PickleError):
  64.     '''This exception is raised when an unpicklable object is passed to the
  65.     dump() method.
  66.  
  67.     '''
  68.     pass
  69.  
  70.  
  71. class UnpicklingError(PickleError):
  72.     '''This exception is raised when there is a problem unpickling an object,
  73.     such as a security violation.
  74.  
  75.     Note that other exceptions may also be raised during unpickling, including
  76.     (but not necessarily limited to) AttributeError, EOFError, ImportError,
  77.     and IndexError.
  78.  
  79.     '''
  80.     pass
  81.  
  82.  
  83. class _Stop(Exception):
  84.     
  85.     def __init__(self, value):
  86.         self.value = value
  87.  
  88.  
  89.  
  90. try:
  91.     from org.python.core import PyStringMap
  92. except ImportError:
  93.     PyStringMap = None
  94.  
  95.  
  96. try:
  97.     UnicodeType
  98. except NameError:
  99.     UnicodeType = None
  100.  
  101. MARK = '('
  102. STOP = '.'
  103. POP = '0'
  104. POP_MARK = '1'
  105. DUP = '2'
  106. FLOAT = 'F'
  107. INT = 'I'
  108. BININT = 'J'
  109. BININT1 = 'K'
  110. LONG = 'L'
  111. BININT2 = 'M'
  112. NONE = 'N'
  113. PERSID = 'P'
  114. BINPERSID = 'Q'
  115. REDUCE = 'R'
  116. STRING = 'S'
  117. BINSTRING = 'T'
  118. SHORT_BINSTRING = 'U'
  119. UNICODE = 'V'
  120. BINUNICODE = 'X'
  121. APPEND = 'a'
  122. BUILD = 'b'
  123. GLOBAL = 'c'
  124. DICT = 'd'
  125. EMPTY_DICT = '}'
  126. APPENDS = 'e'
  127. GET = 'g'
  128. BINGET = 'h'
  129. INST = 'i'
  130. LONG_BINGET = 'j'
  131. LIST = 'l'
  132. EMPTY_LIST = ']'
  133. OBJ = 'o'
  134. PUT = 'p'
  135. BINPUT = 'q'
  136. LONG_BINPUT = 'r'
  137. SETITEM = 's'
  138. TUPLE = 't'
  139. EMPTY_TUPLE = ')'
  140. SETITEMS = 'u'
  141. BINFLOAT = 'G'
  142. TRUE = 'I01\n'
  143. FALSE = 'I00\n'
  144. PROTO = '\x80'
  145. NEWOBJ = '\x81'
  146. EXT1 = '\x82'
  147. EXT2 = '\x83'
  148. EXT4 = '\x84'
  149. TUPLE1 = '\x85'
  150. TUPLE2 = '\x86'
  151. TUPLE3 = '\x87'
  152. NEWTRUE = '\x88'
  153. NEWFALSE = '\x89'
  154. LONG1 = '\x8a'
  155. LONG4 = '\x8b'
  156. _tuplesize2code = [
  157.     EMPTY_TUPLE,
  158.     TUPLE1,
  159.     TUPLE2,
  160.     TUPLE3]
  161. []([] if re.match('[A-Z][A-Z0-9_]+$', x) else _[1])
  162. del x
  163.  
  164. class Pickler:
  165.     
  166.     def __init__(self, file, protocol = None, bin = None):
  167.         '''This takes a file-like object for writing a pickle data stream.
  168.  
  169.         The optional protocol argument tells the pickler to use the
  170.         given protocol; supported protocols are 0, 1, 2.  The default
  171.         protocol is 0, to be backwards compatible.  (Protocol 0 is the
  172.         only protocol that can be written to a file opened in text
  173.         mode and read back successfully.  When using a protocol higher
  174.         than 0, make sure the file is opened in binary mode, both when
  175.         pickling and unpickling.)
  176.  
  177.         Protocol 1 is more efficient than protocol 0; protocol 2 is
  178.         more efficient than protocol 1.
  179.  
  180.         Specifying a negative protocol version selects the highest
  181.         protocol version supported.  The higher the protocol used, the
  182.         more recent the version of Python needed to read the pickle
  183.         produced.
  184.  
  185.         The file parameter must have a write() method that accepts a single
  186.         string argument.  It can thus be an open file object, a StringIO
  187.         object, or any other custom object that meets this interface.
  188.  
  189.         '''
  190.         if protocol is not None and bin is not None:
  191.             raise ValueError, "can't specify both 'protocol' and 'bin'"
  192.         
  193.         if bin is not None:
  194.             warnings.warn("The 'bin' argument to Pickler() is deprecated", DeprecationWarning)
  195.             protocol = bin
  196.         
  197.         if protocol is None:
  198.             protocol = 0
  199.         
  200.         if protocol < 0:
  201.             protocol = HIGHEST_PROTOCOL
  202.         elif protocol <= protocol:
  203.             pass
  204.         elif not protocol <= HIGHEST_PROTOCOL:
  205.             raise ValueError('pickle protocol must be <= %d' % HIGHEST_PROTOCOL)
  206.         
  207.         self.write = file.write
  208.         self.memo = { }
  209.         self.proto = int(protocol)
  210.         self.bin = protocol >= 1
  211.         self.fast = 0
  212.  
  213.     
  214.     def clear_memo(self):
  215.         '''Clears the pickler\'s "memo".
  216.  
  217.         The memo is the data structure that remembers which objects the
  218.         pickler has already seen, so that shared or recursive objects are
  219.         pickled by reference and not by value.  This method is useful when
  220.         re-using picklers.
  221.  
  222.         '''
  223.         self.memo.clear()
  224.  
  225.     
  226.     def dump(self, obj):
  227.         '''Write a pickled representation of obj to the open file.'''
  228.         if self.proto >= 2:
  229.             self.write(PROTO + chr(self.proto))
  230.         
  231.         self.save(obj)
  232.         self.write(STOP)
  233.  
  234.     
  235.     def memoize(self, obj):
  236.         '''Store an object in the memo.'''
  237.         if self.fast:
  238.             return None
  239.         
  240.         memo_len = len(self.memo)
  241.         self.write(self.put(memo_len))
  242.         self.memo[id(obj)] = (memo_len, obj)
  243.  
  244.     
  245.     def put(self, i, pack = struct.pack):
  246.         if self.bin:
  247.             if i < 256:
  248.                 return BINPUT + chr(i)
  249.             else:
  250.                 return LONG_BINPUT + pack('<i', i)
  251.         
  252.         return PUT + repr(i) + '\n'
  253.  
  254.     
  255.     def get(self, i, pack = struct.pack):
  256.         if self.bin:
  257.             if i < 256:
  258.                 return BINGET + chr(i)
  259.             else:
  260.                 return LONG_BINGET + pack('<i', i)
  261.         
  262.         return GET + repr(i) + '\n'
  263.  
  264.     
  265.     def save(self, obj):
  266.         pid = self.persistent_id(obj)
  267.         if pid:
  268.             self.save_pers(pid)
  269.             return None
  270.         
  271.         x = self.memo.get(id(obj))
  272.         if x:
  273.             self.write(self.get(x[0]))
  274.             return None
  275.         
  276.         t = type(obj)
  277.         f = self.dispatch.get(t)
  278.         if f:
  279.             f(self, obj)
  280.             return None
  281.         
  282.         
  283.         try:
  284.             issc = issubclass(t, TypeType)
  285.         except TypeError:
  286.             issc = 0
  287.  
  288.         if issc:
  289.             self.save_global(obj)
  290.             return None
  291.         
  292.         reduce = dispatch_table.get(t)
  293.         if reduce:
  294.             rv = reduce(obj)
  295.         else:
  296.             reduce = getattr(obj, '__reduce_ex__', None)
  297.             if reduce:
  298.                 rv = reduce(self.proto)
  299.             else:
  300.                 reduce = getattr(obj, '__reduce__', None)
  301.                 if reduce:
  302.                     rv = reduce()
  303.                 else:
  304.                     raise PicklingError("Can't pickle %r object: %r" % (t.__name__, obj))
  305.         if type(rv) is StringType:
  306.             self.save_global(obj, rv)
  307.             return None
  308.         
  309.         if type(rv) is not TupleType:
  310.             raise PicklingError('%s must return string or tuple' % reduce)
  311.         
  312.         l = len(rv)
  313.         if l <= l:
  314.             pass
  315.         elif not l <= 5:
  316.             raise PicklingError('Tuple returned by %s must have two to five elements' % reduce)
  317.         
  318.         self.save_reduce(obj = obj, *rv)
  319.  
  320.     
  321.     def persistent_id(self, obj):
  322.         pass
  323.  
  324.     
  325.     def save_pers(self, pid):
  326.         if self.bin:
  327.             self.save(pid)
  328.             self.write(BINPERSID)
  329.         else:
  330.             self.write(PERSID + str(pid) + '\n')
  331.  
  332.     
  333.     def save_reduce(self, func, args, state = None, listitems = None, dictitems = None, obj = None):
  334.         if not isinstance(args, TupleType):
  335.             if args is None:
  336.                 warnings.warn('__basicnew__ special case is deprecated', DeprecationWarning)
  337.             else:
  338.                 raise PicklingError('args from reduce() should be a tuple')
  339.         
  340.         if not callable(func):
  341.             raise PicklingError('func from reduce should be callable')
  342.         
  343.         save = self.save
  344.         write = self.write
  345.         if self.proto >= 2 and getattr(func, '__name__', '') == '__newobj__':
  346.             cls = args[0]
  347.             if not hasattr(cls, '__new__'):
  348.                 raise PicklingError('args[0] from __newobj__ args has no __new__')
  349.             
  350.             if obj is not None and cls is not obj.__class__:
  351.                 raise PicklingError('args[0] from __newobj__ args has the wrong class')
  352.             
  353.             args = args[1:]
  354.             save(cls)
  355.             save(args)
  356.             write(NEWOBJ)
  357.         else:
  358.             save(func)
  359.             save(args)
  360.             write(REDUCE)
  361.         if obj is not None:
  362.             self.memoize(obj)
  363.         
  364.         if listitems is not None:
  365.             self._batch_appends(listitems)
  366.         
  367.         if dictitems is not None:
  368.             self._batch_setitems(dictitems)
  369.         
  370.         if state is not None:
  371.             save(state)
  372.             write(BUILD)
  373.         
  374.  
  375.     dispatch = { }
  376.     
  377.     def save_none(self, obj):
  378.         self.write(NONE)
  379.  
  380.     dispatch[NoneType] = save_none
  381.     
  382.     def save_bool(self, obj):
  383.         None(self.write if self.proto >= 2 else FALSE)
  384.  
  385.     dispatch[bool] = save_bool
  386.     
  387.     def save_int(self, obj, pack = struct.pack):
  388.         if self.bin:
  389.             if obj >= 0:
  390.                 if obj <= 255:
  391.                     self.write(BININT1 + chr(obj))
  392.                     return None
  393.                 
  394.                 if obj <= 65535:
  395.                     self.write('%c%c%c' % (BININT2, obj & 255, obj >> 8))
  396.                     return None
  397.                 
  398.             
  399.             high_bits = obj >> 31
  400.             if high_bits == 0 or high_bits == -1:
  401.                 self.write(BININT + pack('<i', obj))
  402.                 return None
  403.             
  404.         
  405.         self.write(INT + repr(obj) + '\n')
  406.  
  407.     dispatch[IntType] = save_int
  408.     
  409.     def save_long(self, obj, pack = struct.pack):
  410.         if self.proto >= 2:
  411.             bytes = encode_long(obj)
  412.             n = len(bytes)
  413.             if n < 256:
  414.                 self.write(LONG1 + chr(n) + bytes)
  415.             else:
  416.                 self.write(LONG4 + pack('<i', n) + bytes)
  417.             return None
  418.         
  419.         self.write(LONG + repr(obj) + '\n')
  420.  
  421.     dispatch[LongType] = save_long
  422.     
  423.     def save_float(self, obj, pack = struct.pack):
  424.         if self.bin:
  425.             self.write(BINFLOAT + pack('>d', obj))
  426.         else:
  427.             self.write(FLOAT + repr(obj) + '\n')
  428.  
  429.     dispatch[FloatType] = save_float
  430.     
  431.     def save_string(self, obj, pack = struct.pack):
  432.         if self.bin:
  433.             n = len(obj)
  434.             if n < 256:
  435.                 self.write(SHORT_BINSTRING + chr(n) + obj)
  436.             else:
  437.                 self.write(BINSTRING + pack('<i', n) + obj)
  438.         else:
  439.             self.write(STRING + repr(obj) + '\n')
  440.         self.memoize(obj)
  441.  
  442.     dispatch[StringType] = save_string
  443.     
  444.     def save_unicode(self, obj, pack = struct.pack):
  445.         if self.bin:
  446.             encoding = obj.encode('utf-8')
  447.             n = len(encoding)
  448.             self.write(BINUNICODE + pack('<i', n) + encoding)
  449.         else:
  450.             obj = obj.replace('\\', '\\u005c')
  451.             obj = obj.replace('\n', '\\u000a')
  452.             self.write(UNICODE + obj.encode('raw-unicode-escape') + '\n')
  453.         self.memoize(obj)
  454.  
  455.     dispatch[UnicodeType] = save_unicode
  456.     if StringType == UnicodeType:
  457.         
  458.         def save_string(self, obj, pack = struct.pack):
  459.             unicode = obj.isunicode()
  460.             if self.bin:
  461.                 if unicode:
  462.                     obj = obj.encode('utf-8')
  463.                 
  464.                 l = len(obj)
  465.                 if l < 256 and not unicode:
  466.                     self.write(SHORT_BINSTRING + chr(l) + obj)
  467.                 else:
  468.                     s = pack('<i', l)
  469.                     if unicode:
  470.                         self.write(BINUNICODE + s + obj)
  471.                     else:
  472.                         self.write(BINSTRING + s + obj)
  473.             elif unicode:
  474.                 obj = obj.replace('\\', '\\u005c')
  475.                 obj = obj.replace('\n', '\\u000a')
  476.                 obj = obj.encode('raw-unicode-escape')
  477.                 self.write(UNICODE + obj + '\n')
  478.             else:
  479.                 self.write(STRING + repr(obj) + '\n')
  480.             self.memoize(obj)
  481.  
  482.         dispatch[StringType] = save_string
  483.     
  484.     
  485.     def save_tuple(self, obj):
  486.         write = self.write
  487.         proto = self.proto
  488.         n = len(obj)
  489.         if n == 0:
  490.             if proto:
  491.                 write(EMPTY_TUPLE)
  492.             else:
  493.                 write(MARK + TUPLE)
  494.             return None
  495.         
  496.         save = self.save
  497.         memo = self.memo
  498.         if n <= 3 and proto >= 2:
  499.             for element in obj:
  500.                 save(element)
  501.             
  502.             if id(obj) in memo:
  503.                 get = self.get(memo[id(obj)][0])
  504.                 write(POP * n + get)
  505.             else:
  506.                 write(_tuplesize2code[n])
  507.                 self.memoize(obj)
  508.             return None
  509.         
  510.         write(MARK)
  511.         for element in obj:
  512.             save(element)
  513.         
  514.         if id(obj) in memo:
  515.             get = self.get(memo[id(obj)][0])
  516.             if proto:
  517.                 write(POP_MARK + get)
  518.             else:
  519.                 write(POP * (n + 1) + get)
  520.             return None
  521.         
  522.         self.write(TUPLE)
  523.         self.memoize(obj)
  524.  
  525.     dispatch[TupleType] = save_tuple
  526.     
  527.     def save_empty_tuple(self, obj):
  528.         self.write(EMPTY_TUPLE)
  529.  
  530.     
  531.     def save_list(self, obj):
  532.         write = self.write
  533.         if self.bin:
  534.             write(EMPTY_LIST)
  535.         else:
  536.             write(MARK + LIST)
  537.         self.memoize(obj)
  538.         self._batch_appends(iter(obj))
  539.  
  540.     dispatch[ListType] = save_list
  541.     _BATCHSIZE = 1000
  542.     
  543.     def _batch_appends(self, items):
  544.         save = self.save
  545.         write = self.write
  546.         if not self.bin:
  547.             for x in items:
  548.                 save(x)
  549.                 write(APPEND)
  550.             
  551.             return None
  552.         
  553.         r = xrange(self._BATCHSIZE)
  554.         while items is not None:
  555.             tmp = []
  556.             for i in r:
  557.                 
  558.                 try:
  559.                     x = items.next()
  560.                     tmp.append(x)
  561.                 continue
  562.                 except StopIteration:
  563.                     items = None
  564.                     break
  565.                     continue
  566.                 
  567.  
  568.             
  569.             n = len(tmp)
  570.             if n > 1:
  571.                 write(MARK)
  572.                 for x in tmp:
  573.                     save(x)
  574.                 
  575.                 write(APPENDS)
  576.                 continue
  577.             None<EXCEPTION MATCH>StopIteration
  578.             if n:
  579.                 save(tmp[0])
  580.                 write(APPEND)
  581.                 continue
  582.  
  583.     
  584.     def save_dict(self, obj):
  585.         write = self.write
  586.         if self.bin:
  587.             write(EMPTY_DICT)
  588.         else:
  589.             write(MARK + DICT)
  590.         self.memoize(obj)
  591.         self._batch_setitems(obj.iteritems())
  592.  
  593.     dispatch[DictionaryType] = save_dict
  594.     if PyStringMap is not None:
  595.         dispatch[PyStringMap] = save_dict
  596.     
  597.     
  598.     def _batch_setitems(self, items):
  599.         save = self.save
  600.         write = self.write
  601.         if not self.bin:
  602.             for k, v in items:
  603.                 save(k)
  604.                 save(v)
  605.                 write(SETITEM)
  606.             
  607.             return None
  608.         
  609.         r = xrange(self._BATCHSIZE)
  610.         while items is not None:
  611.             tmp = []
  612.             for i in r:
  613.                 
  614.                 try:
  615.                     tmp.append(items.next())
  616.                 continue
  617.                 except StopIteration:
  618.                     items = None
  619.                     break
  620.                     continue
  621.                 
  622.  
  623.             
  624.             n = len(tmp)
  625.             if n > 1:
  626.                 write(MARK)
  627.                 for k, v in tmp:
  628.                     save(k)
  629.                     save(v)
  630.                 
  631.                 write(SETITEMS)
  632.                 continue
  633.             None<EXCEPTION MATCH>StopIteration
  634.             if n:
  635.                 (k, v) = tmp[0]
  636.                 save(k)
  637.                 save(v)
  638.                 write(SETITEM)
  639.                 continue
  640.  
  641.     
  642.     def save_inst(self, obj):
  643.         cls = obj.__class__
  644.         memo = self.memo
  645.         write = self.write
  646.         save = self.save
  647.         if hasattr(obj, '__getinitargs__'):
  648.             args = obj.__getinitargs__()
  649.             len(args)
  650.             _keep_alive(args, memo)
  651.         else:
  652.             args = ()
  653.         write(MARK)
  654.         if self.bin:
  655.             save(cls)
  656.             for arg in args:
  657.                 save(arg)
  658.             
  659.             write(OBJ)
  660.         else:
  661.             for arg in args:
  662.                 save(arg)
  663.             
  664.             write(INST + cls.__module__ + '\n' + cls.__name__ + '\n')
  665.         self.memoize(obj)
  666.         
  667.         try:
  668.             getstate = obj.__getstate__
  669.         except AttributeError:
  670.             stuff = obj.__dict__
  671.  
  672.         stuff = getstate()
  673.         _keep_alive(stuff, memo)
  674.         save(stuff)
  675.         write(BUILD)
  676.  
  677.     dispatch[InstanceType] = save_inst
  678.     
  679.     def save_global(self, obj, name = None, pack = struct.pack):
  680.         write = self.write
  681.         memo = self.memo
  682.         if name is None:
  683.             name = obj.__name__
  684.         
  685.         module = getattr(obj, '__module__', None)
  686.         if module is None:
  687.             module = whichmodule(obj, name)
  688.         
  689.         
  690.         try:
  691.             __import__(module)
  692.             mod = sys.modules[module]
  693.             klass = getattr(mod, name)
  694.         except (ImportError, KeyError, AttributeError):
  695.             raise PicklingError("Can't pickle %r: it's not found as %s.%s" % (obj, module, name))
  696.  
  697.         if klass is not obj:
  698.             raise PicklingError("Can't pickle %r: it's not the same object as %s.%s" % (obj, module, name))
  699.         
  700.         if self.proto >= 2:
  701.             code = _extension_registry.get((module, name))
  702.             if code:
  703.                 if code <= 255:
  704.                     write(EXT1 + chr(code))
  705.                 elif code <= 65535:
  706.                     write('%c%c%c' % (EXT2, code & 255, code >> 8))
  707.                 else:
  708.                     write(EXT4 + pack('<i', code))
  709.                 return None
  710.             
  711.         
  712.         write(GLOBAL + module + '\n' + name + '\n')
  713.         self.memoize(obj)
  714.  
  715.     dispatch[ClassType] = save_global
  716.     dispatch[FunctionType] = save_global
  717.     dispatch[BuiltinFunctionType] = save_global
  718.     dispatch[TypeType] = save_global
  719.  
  720.  
  721. def _keep_alive(x, memo):
  722.     '''Keeps a reference to the object x in the memo.
  723.  
  724.     Because we remember objects by their id, we have
  725.     to assure that possibly temporary objects are kept
  726.     alive by referencing them.
  727.     We store a reference at the id of the memo, which should
  728.     normally not be used unless someone tries to deepcopy
  729.     the memo itself...
  730.     '''
  731.     
  732.     try:
  733.         memo[id(memo)].append(x)
  734.     except KeyError:
  735.         memo[id(memo)] = [
  736.             x]
  737.  
  738.  
  739. classmap = { }
  740.  
  741. def whichmodule(func, funcname):
  742.     '''Figure out the module in which a function occurs.
  743.  
  744.     Search sys.modules for the module.
  745.     Cache in classmap.
  746.     Return a module name.
  747.     If the function cannot be found, return "__main__".
  748.     '''
  749.     mod = getattr(func, '__module__', None)
  750.     if mod is not None:
  751.         return mod
  752.     
  753.     if func in classmap:
  754.         return classmap[func]
  755.     
  756.     for name, module in sys.modules.items():
  757.         if module is None:
  758.             continue
  759.         
  760.         if name != '__main__' and getattr(module, funcname, None) is func:
  761.             break
  762.             continue
  763.     else:
  764.         name = '__main__'
  765.     classmap[func] = name
  766.     return name
  767.  
  768.  
  769. class Unpickler:
  770.     
  771.     def __init__(self, file):
  772.         '''This takes a file-like object for reading a pickle data stream.
  773.  
  774.         The protocol version of the pickle is detected automatically, so no
  775.         proto argument is needed.
  776.  
  777.         The file-like object must have two methods, a read() method that
  778.         takes an integer argument, and a readline() method that requires no
  779.         arguments.  Both methods should return a string.  Thus file-like
  780.         object can be a file object opened for reading, a StringIO object,
  781.         or any other custom object that meets this interface.
  782.         '''
  783.         self.readline = file.readline
  784.         self.read = file.read
  785.         self.memo = { }
  786.  
  787.     
  788.     def load(self):
  789.         '''Read a pickled object representation from the open file.
  790.  
  791.         Return the reconstituted object hierarchy specified in the file.
  792.         '''
  793.         self.mark = object()
  794.         self.stack = []
  795.         self.append = self.stack.append
  796.         read = self.read
  797.         dispatch = self.dispatch
  798.         
  799.         try:
  800.             while None:
  801.                 key = read(1)
  802.         except _Stop:
  803.             stopinst = None
  804.             return stopinst.value
  805.  
  806.  
  807.     
  808.     def marker(self):
  809.         stack = self.stack
  810.         mark = self.mark
  811.         k = len(stack) - 1
  812.         while stack[k] is not mark:
  813.             k = k - 1
  814.         return k
  815.  
  816.     dispatch = { }
  817.     
  818.     def load_eof(self):
  819.         raise EOFError
  820.  
  821.     dispatch[''] = load_eof
  822.     
  823.     def load_proto(self):
  824.         proto = ord(self.read(1))
  825.         if proto <= proto:
  826.             pass
  827.         elif not proto <= 2:
  828.             raise ValueError, 'unsupported pickle protocol: %d' % proto
  829.         
  830.  
  831.     dispatch[PROTO] = load_proto
  832.     
  833.     def load_persid(self):
  834.         pid = self.readline()[:-1]
  835.         self.append(self.persistent_load(pid))
  836.  
  837.     dispatch[PERSID] = load_persid
  838.     
  839.     def load_binpersid(self):
  840.         pid = self.stack.pop()
  841.         self.append(self.persistent_load(pid))
  842.  
  843.     dispatch[BINPERSID] = load_binpersid
  844.     
  845.     def load_none(self):
  846.         self.append(None)
  847.  
  848.     dispatch[NONE] = load_none
  849.     
  850.     def load_false(self):
  851.         self.append(False)
  852.  
  853.     dispatch[NEWFALSE] = load_false
  854.     
  855.     def load_true(self):
  856.         self.append(True)
  857.  
  858.     dispatch[NEWTRUE] = load_true
  859.     
  860.     def load_int(self):
  861.         data = self.readline()
  862.         if data == FALSE[1:]:
  863.             val = False
  864.         elif data == TRUE[1:]:
  865.             val = True
  866.         else:
  867.             
  868.             try:
  869.                 val = int(data)
  870.             except ValueError:
  871.                 val = long(data)
  872.  
  873.         self.append(val)
  874.  
  875.     dispatch[INT] = load_int
  876.     
  877.     def load_binint(self):
  878.         self.append(mloads('i' + self.read(4)))
  879.  
  880.     dispatch[BININT] = load_binint
  881.     
  882.     def load_binint1(self):
  883.         self.append(ord(self.read(1)))
  884.  
  885.     dispatch[BININT1] = load_binint1
  886.     
  887.     def load_binint2(self):
  888.         self.append(mloads('i' + self.read(2) + '\x00\x00'))
  889.  
  890.     dispatch[BININT2] = load_binint2
  891.     
  892.     def load_long(self):
  893.         self.append(long(self.readline()[:-1], 0))
  894.  
  895.     dispatch[LONG] = load_long
  896.     
  897.     def load_long1(self):
  898.         n = ord(self.read(1))
  899.         bytes = self.read(n)
  900.         self.append(decode_long(bytes))
  901.  
  902.     dispatch[LONG1] = load_long1
  903.     
  904.     def load_long4(self):
  905.         n = mloads('i' + self.read(4))
  906.         bytes = self.read(n)
  907.         self.append(decode_long(bytes))
  908.  
  909.     dispatch[LONG4] = load_long4
  910.     
  911.     def load_float(self):
  912.         self.append(float(self.readline()[:-1]))
  913.  
  914.     dispatch[FLOAT] = load_float
  915.     
  916.     def load_binfloat(self, unpack = struct.unpack):
  917.         self.append(unpack('>d', self.read(8))[0])
  918.  
  919.     dispatch[BINFLOAT] = load_binfloat
  920.     
  921.     def load_string(self):
  922.         rep = self.readline()[:-1]
  923.         for q in '"\'':
  924.             if rep.startswith(q):
  925.                 if not rep.endswith(q):
  926.                     raise ValueError, 'insecure string pickle'
  927.                 
  928.                 rep = rep[len(q):-len(q)]
  929.                 break
  930.                 continue
  931.         else:
  932.             raise ValueError, 'insecure string pickle'
  933.         self.append(rep.decode('string-escape'))
  934.  
  935.     dispatch[STRING] = load_string
  936.     
  937.     def load_binstring(self):
  938.         len = mloads('i' + self.read(4))
  939.         self.append(self.read(len))
  940.  
  941.     dispatch[BINSTRING] = load_binstring
  942.     
  943.     def load_unicode(self):
  944.         self.append(unicode(self.readline()[:-1], 'raw-unicode-escape'))
  945.  
  946.     dispatch[UNICODE] = load_unicode
  947.     
  948.     def load_binunicode(self):
  949.         len = mloads('i' + self.read(4))
  950.         self.append(unicode(self.read(len), 'utf-8'))
  951.  
  952.     dispatch[BINUNICODE] = load_binunicode
  953.     
  954.     def load_short_binstring(self):
  955.         len = ord(self.read(1))
  956.         self.append(self.read(len))
  957.  
  958.     dispatch[SHORT_BINSTRING] = load_short_binstring
  959.     
  960.     def load_tuple(self):
  961.         k = self.marker()
  962.         self.stack[k:] = [
  963.             tuple(self.stack[k + 1:])]
  964.  
  965.     dispatch[TUPLE] = load_tuple
  966.     
  967.     def load_empty_tuple(self):
  968.         self.stack.append(())
  969.  
  970.     dispatch[EMPTY_TUPLE] = load_empty_tuple
  971.     
  972.     def load_tuple1(self):
  973.         self.stack[-1] = (self.stack[-1],)
  974.  
  975.     dispatch[TUPLE1] = load_tuple1
  976.     
  977.     def load_tuple2(self):
  978.         self.stack[-2:] = [
  979.             (self.stack[-2], self.stack[-1])]
  980.  
  981.     dispatch[TUPLE2] = load_tuple2
  982.     
  983.     def load_tuple3(self):
  984.         self.stack[-3:] = [
  985.             (self.stack[-3], self.stack[-2], self.stack[-1])]
  986.  
  987.     dispatch[TUPLE3] = load_tuple3
  988.     
  989.     def load_empty_list(self):
  990.         self.stack.append([])
  991.  
  992.     dispatch[EMPTY_LIST] = load_empty_list
  993.     
  994.     def load_empty_dictionary(self):
  995.         self.stack.append({ })
  996.  
  997.     dispatch[EMPTY_DICT] = load_empty_dictionary
  998.     
  999.     def load_list(self):
  1000.         k = self.marker()
  1001.         self.stack[k:] = [
  1002.             self.stack[k + 1:]]
  1003.  
  1004.     dispatch[LIST] = load_list
  1005.     
  1006.     def load_dict(self):
  1007.         k = self.marker()
  1008.         d = { }
  1009.         items = self.stack[k + 1:]
  1010.         for i in range(0, len(items), 2):
  1011.             key = items[i]
  1012.             value = items[i + 1]
  1013.             d[key] = value
  1014.         
  1015.         self.stack[k:] = [
  1016.             d]
  1017.  
  1018.     dispatch[DICT] = load_dict
  1019.     
  1020.     def _instantiate(self, klass, k):
  1021.         args = tuple(self.stack[k + 1:])
  1022.         del self.stack[k:]
  1023.         instantiated = 0
  1024.         if not args and type(klass) is ClassType and not hasattr(klass, '__getinitargs__'):
  1025.             
  1026.             try:
  1027.                 value = _EmptyClass()
  1028.                 value.__class__ = klass
  1029.                 instantiated = 1
  1030.             except RuntimeError:
  1031.                 pass
  1032.             except:
  1033.                 None<EXCEPTION MATCH>RuntimeError
  1034.             
  1035.  
  1036.         None<EXCEPTION MATCH>RuntimeError
  1037.         if not instantiated:
  1038.             
  1039.             try:
  1040.                 value = klass(*args)
  1041.             except TypeError:
  1042.                 err = None
  1043.                 raise TypeError, 'in constructor for %s: %s' % (klass.__name__, str(err)), sys.exc_info()[2]
  1044.             except:
  1045.                 None<EXCEPTION MATCH>TypeError
  1046.             
  1047.  
  1048.         None<EXCEPTION MATCH>TypeError
  1049.         self.append(value)
  1050.  
  1051.     
  1052.     def load_inst(self):
  1053.         module = self.readline()[:-1]
  1054.         name = self.readline()[:-1]
  1055.         klass = self.find_class(module, name)
  1056.         self._instantiate(klass, self.marker())
  1057.  
  1058.     dispatch[INST] = load_inst
  1059.     
  1060.     def load_obj(self):
  1061.         k = self.marker()
  1062.         klass = self.stack.pop(k + 1)
  1063.         self._instantiate(klass, k)
  1064.  
  1065.     dispatch[OBJ] = load_obj
  1066.     
  1067.     def load_newobj(self):
  1068.         args = self.stack.pop()
  1069.         cls = self.stack[-1]
  1070.         obj = cls.__new__(cls, *args)
  1071.         self.stack[-1] = obj
  1072.  
  1073.     dispatch[NEWOBJ] = load_newobj
  1074.     
  1075.     def load_global(self):
  1076.         module = self.readline()[:-1]
  1077.         name = self.readline()[:-1]
  1078.         klass = self.find_class(module, name)
  1079.         self.append(klass)
  1080.  
  1081.     dispatch[GLOBAL] = load_global
  1082.     
  1083.     def load_ext1(self):
  1084.         code = ord(self.read(1))
  1085.         self.get_extension(code)
  1086.  
  1087.     dispatch[EXT1] = load_ext1
  1088.     
  1089.     def load_ext2(self):
  1090.         code = mloads('i' + self.read(2) + '\x00\x00')
  1091.         self.get_extension(code)
  1092.  
  1093.     dispatch[EXT2] = load_ext2
  1094.     
  1095.     def load_ext4(self):
  1096.         code = mloads('i' + self.read(4))
  1097.         self.get_extension(code)
  1098.  
  1099.     dispatch[EXT4] = load_ext4
  1100.     
  1101.     def get_extension(self, code):
  1102.         nil = []
  1103.         obj = _extension_cache.get(code, nil)
  1104.         if obj is not nil:
  1105.             self.append(obj)
  1106.             return None
  1107.         
  1108.         key = _inverted_registry.get(code)
  1109.         if not key:
  1110.             raise ValueError('unregistered extension code %d' % code)
  1111.         
  1112.         obj = self.find_class(*key)
  1113.         _extension_cache[code] = obj
  1114.         self.append(obj)
  1115.  
  1116.     
  1117.     def find_class(self, module, name):
  1118.         __import__(module)
  1119.         mod = sys.modules[module]
  1120.         klass = getattr(mod, name)
  1121.         return klass
  1122.  
  1123.     
  1124.     def load_reduce(self):
  1125.         stack = self.stack
  1126.         args = stack.pop()
  1127.         func = stack[-1]
  1128.         if args is None:
  1129.             warnings.warn('__basicnew__ special case is deprecated', DeprecationWarning)
  1130.             value = func.__basicnew__()
  1131.         else:
  1132.             value = func(*args)
  1133.         stack[-1] = value
  1134.  
  1135.     dispatch[REDUCE] = load_reduce
  1136.     
  1137.     def load_pop(self):
  1138.         del self.stack[-1]
  1139.  
  1140.     dispatch[POP] = load_pop
  1141.     
  1142.     def load_pop_mark(self):
  1143.         k = self.marker()
  1144.         del self.stack[k:]
  1145.  
  1146.     dispatch[POP_MARK] = load_pop_mark
  1147.     
  1148.     def load_dup(self):
  1149.         self.append(self.stack[-1])
  1150.  
  1151.     dispatch[DUP] = load_dup
  1152.     
  1153.     def load_get(self):
  1154.         self.append(self.memo[self.readline()[:-1]])
  1155.  
  1156.     dispatch[GET] = load_get
  1157.     
  1158.     def load_binget(self):
  1159.         i = ord(self.read(1))
  1160.         self.append(self.memo[repr(i)])
  1161.  
  1162.     dispatch[BINGET] = load_binget
  1163.     
  1164.     def load_long_binget(self):
  1165.         i = mloads('i' + self.read(4))
  1166.         self.append(self.memo[repr(i)])
  1167.  
  1168.     dispatch[LONG_BINGET] = load_long_binget
  1169.     
  1170.     def load_put(self):
  1171.         self.memo[self.readline()[:-1]] = self.stack[-1]
  1172.  
  1173.     dispatch[PUT] = load_put
  1174.     
  1175.     def load_binput(self):
  1176.         i = ord(self.read(1))
  1177.         self.memo[repr(i)] = self.stack[-1]
  1178.  
  1179.     dispatch[BINPUT] = load_binput
  1180.     
  1181.     def load_long_binput(self):
  1182.         i = mloads('i' + self.read(4))
  1183.         self.memo[repr(i)] = self.stack[-1]
  1184.  
  1185.     dispatch[LONG_BINPUT] = load_long_binput
  1186.     
  1187.     def load_append(self):
  1188.         stack = self.stack
  1189.         value = stack.pop()
  1190.         list = stack[-1]
  1191.         list.append(value)
  1192.  
  1193.     dispatch[APPEND] = load_append
  1194.     
  1195.     def load_appends(self):
  1196.         stack = self.stack
  1197.         mark = self.marker()
  1198.         list = stack[mark - 1]
  1199.         list.extend(stack[mark + 1:])
  1200.         del stack[mark:]
  1201.  
  1202.     dispatch[APPENDS] = load_appends
  1203.     
  1204.     def load_setitem(self):
  1205.         stack = self.stack
  1206.         value = stack.pop()
  1207.         key = stack.pop()
  1208.         dict = stack[-1]
  1209.         dict[key] = value
  1210.  
  1211.     dispatch[SETITEM] = load_setitem
  1212.     
  1213.     def load_setitems(self):
  1214.         stack = self.stack
  1215.         mark = self.marker()
  1216.         dict = stack[mark - 1]
  1217.         for i in range(mark + 1, len(stack), 2):
  1218.             dict[stack[i]] = stack[i + 1]
  1219.         
  1220.         del stack[mark:]
  1221.  
  1222.     dispatch[SETITEMS] = load_setitems
  1223.     
  1224.     def load_build(self):
  1225.         stack = self.stack
  1226.         state = stack.pop()
  1227.         inst = stack[-1]
  1228.         setstate = getattr(inst, '__setstate__', None)
  1229.         if setstate:
  1230.             setstate(state)
  1231.             return None
  1232.         
  1233.         slotstate = None
  1234.         if isinstance(state, tuple) and len(state) == 2:
  1235.             (state, slotstate) = state
  1236.         
  1237.         if state:
  1238.             
  1239.             try:
  1240.                 inst.__dict__.update(state)
  1241.             except RuntimeError:
  1242.                 for k, v in state.items():
  1243.                     setattr(inst, k, v)
  1244.                 
  1245.             
  1246.  
  1247.         None<EXCEPTION MATCH>RuntimeError
  1248.         if slotstate:
  1249.             for k, v in slotstate.items():
  1250.                 setattr(inst, k, v)
  1251.             
  1252.         
  1253.  
  1254.     dispatch[BUILD] = load_build
  1255.     
  1256.     def load_mark(self):
  1257.         self.append(self.mark)
  1258.  
  1259.     dispatch[MARK] = load_mark
  1260.     
  1261.     def load_stop(self):
  1262.         value = self.stack.pop()
  1263.         raise _Stop(value)
  1264.  
  1265.     dispatch[STOP] = load_stop
  1266.  
  1267.  
  1268. class _EmptyClass:
  1269.     pass
  1270.  
  1271. import binascii as _binascii
  1272.  
  1273. def encode_long(x):
  1274.     """Encode a long to a two's complement little-endian binary string.
  1275.     Note that 0L is a special case, returning an empty string, to save a
  1276.     byte in the LONG1 pickling context.
  1277.  
  1278.     >>> encode_long(0L)
  1279.     ''
  1280.     >>> encode_long(255L)
  1281.     '\\xff\\x00'
  1282.     >>> encode_long(32767L)
  1283.     '\\xff\\x7f'
  1284.     >>> encode_long(-256L)
  1285.     '\\x00\\xff'
  1286.     >>> encode_long(-32768L)
  1287.     '\\x00\\x80'
  1288.     >>> encode_long(-128L)
  1289.     '\\x80'
  1290.     >>> encode_long(127L)
  1291.     '\\x7f'
  1292.     >>>
  1293.     """
  1294.     if x == 0:
  1295.         return ''
  1296.     
  1297.     if x > 0:
  1298.         ashex = hex(x)
  1299.         njunkchars = 2 + ashex.endswith('L')
  1300.         nibbles = len(ashex) - njunkchars
  1301.         if nibbles & 1:
  1302.             ashex = '0x0' + ashex[2:]
  1303.         elif int(ashex[2], 16) >= 8:
  1304.             ashex = '0x00' + ashex[2:]
  1305.         
  1306.     else:
  1307.         ashex = hex(-x)
  1308.         njunkchars = 2 + ashex.endswith('L')
  1309.         nibbles = len(ashex) - njunkchars
  1310.         if nibbles & 1:
  1311.             nibbles += 1
  1312.         
  1313.         nbits = nibbles * 4
  1314.         x += 0x1L << nbits
  1315.         ashex = hex(x)
  1316.         njunkchars = 2 + ashex.endswith('L')
  1317.         newnibbles = len(ashex) - njunkchars
  1318.         if newnibbles < nibbles:
  1319.             ashex = '0x' + '0' * (nibbles - newnibbles) + ashex[2:]
  1320.         
  1321.         if int(ashex[2], 16) < 8:
  1322.             ashex = '0xff' + ashex[2:]
  1323.         
  1324.     if ashex.endswith('L'):
  1325.         ashex = ashex[2:-1]
  1326.     else:
  1327.         ashex = ashex[2:]
  1328.     binary = _binascii.unhexlify(ashex)
  1329.     return binary[::-1]
  1330.  
  1331.  
  1332. def decode_long(data):
  1333.     '''Decode a long from a two\'s complement little-endian binary string.
  1334.  
  1335.     >>> decode_long(\'\')
  1336.     0L
  1337.     >>> decode_long("\\xff\\x00")
  1338.     255L
  1339.     >>> decode_long("\\xff\\x7f")
  1340.     32767L
  1341.     >>> decode_long("\\x00\\xff")
  1342.     -256L
  1343.     >>> decode_long("\\x00\\x80")
  1344.     -32768L
  1345.     >>> decode_long("\\x80")
  1346.     -128L
  1347.     >>> decode_long("\\x7f")
  1348.     127L
  1349.     '''
  1350.     nbytes = len(data)
  1351.     if nbytes == 0:
  1352.         return 0x0L
  1353.     
  1354.     ashex = _binascii.hexlify(data[::-1])
  1355.     n = long(ashex, 16)
  1356.     if data[-1] >= '\x80':
  1357.         n -= 0x1L << nbytes * 8
  1358.     
  1359.     return n
  1360.  
  1361.  
  1362. try:
  1363.     from cStringIO import StringIO
  1364. except ImportError:
  1365.     __all__.extend
  1366.     __all__.extend
  1367.     from StringIO import StringIO
  1368. except:
  1369.     __all__.extend
  1370.  
  1371.  
  1372. def dump(obj, file, protocol = None, bin = None):
  1373.     Pickler(file, protocol, bin).dump(obj)
  1374.  
  1375.  
  1376. def dumps(obj, protocol = None, bin = None):
  1377.     file = StringIO()
  1378.     Pickler(file, protocol, bin).dump(obj)
  1379.     return file.getvalue()
  1380.  
  1381.  
  1382. def load(file):
  1383.     return Unpickler(file).load()
  1384.  
  1385.  
  1386. def loads(str):
  1387.     file = StringIO(str)
  1388.     return Unpickler(file).load()
  1389.  
  1390.  
  1391. def _test():
  1392.     import doctest as doctest
  1393.     return doctest.testmod()
  1394.  
  1395. if __name__ == '__main__':
  1396.     _test()
  1397.  
  1398.